From b517c2bb2809f89b0118e1d07dc2e25cfe4468ce Mon Sep 17 00:00:00 2001
From: Ilya Rezvov <ilya.rezvov@revjet.com>
Date: Mon, 22 Jan 2018 20:41:58 -0800
Subject: [PATCH] improve test runner

---
 package.yaml                |    1 +
 tests/Test.hs               |   18 +-
 tests/samples/comments.wast |   24 +-
 tests/samples/f64.wast      | 2501 -----------------------------------
 tests/samples/i64.wast      |  388 ------
 wasm.cabal                  |    1 +
 6 files changed, 18 insertions(+), 2915 deletions(-)

diff --git a/package.yaml b/package.yaml
index d669084..8598f1d 100644
--- a/package.yaml
+++ b/package.yaml
@@ -38,6 +38,7 @@ tests:
     dependencies:
     - wasm == 0.1.0
     - filepath >=1.3 && <1.5
+    - directory >= 1.3
     - text >=1.1 && <1.3
     - bytestring >=0.10 && <0.11
     - mtl ==2.2.1
diff --git a/tests/Test.hs b/tests/Test.hs
index 5fa7682..b70797c 100644
--- a/tests/Test.hs
+++ b/tests/Test.hs
@@ -5,13 +5,25 @@ module Main (
 import Test.Tasty
 import Test.Tasty.HUnit
 
+import qualified System.Directory as Directory
+
 import qualified Data.ByteString.Lazy as LBS
 
 import qualified Language.Wasm.Lexer as Lexer
 import qualified Language.Wasm.Parser as Parser
 
+import qualified Debug.Trace as Debug
+
+isRight :: (Show b) => Either a b -> Bool
+isRight (Right x) = length (show x) > 0
+isRight _         = False
+
 main :: IO ()
 main = do
-  file <- LBS.readFile "tests/samples/switch.wast"
-  print $ Parser.parseModule <$> Lexer.scanner file
-  defaultMain $ testGroup "Test Suite" []
+  files <- Directory.listDirectory "tests/samples"
+  testCases <- (`mapM` files) $ \file -> do
+    content <- LBS.readFile $ "tests/samples/" ++ file
+    let result = Parser.parseModule <$> Lexer.scanner content
+    return $ testCase ("Parse module from core Test Suit: " ++ file) $
+      assertBool "Module parsed" $ isRight result
+  defaultMain $ testGroup "Syntax parsing" testCases
diff --git a/tests/samples/comments.wast b/tests/samples/comments.wast
index 5854947..a177efb 100644
--- a/tests/samples/comments.wast
+++ b/tests/samples/comments.wast
@@ -48,26 +48,4 @@ comment;)
 
          	(;comment;)
 
-(;comment;)((;comment;)
-(;comment;)module(;comment;)
-(;comment;))(;comment;)
-
-(;comment(;nested;)comment;)
-
-(;comment
-(;nested
-;)comment
-;)
-
-(module
-  (;comment(;nested(;further;)nested;)comment;)
-)
-
-(;comment;;comment;)
-
-(;comment;;comment
-;)
-
-(module
-  (;comment;;comment(;nested;)comment;)
-)
+(;comment;)
\ No newline at end of file
diff --git a/tests/samples/f64.wast b/tests/samples/f64.wast
index 0c972f6..09225db 100644
--- a/tests/samples/f64.wast
+++ b/tests/samples/f64.wast
@@ -15,2504 +15,3 @@
   (func (export "trunc") (param $x f64) (result f64) (f64.trunc (get_local $x)))
   (func (export "nearest") (param $x f64) (result f64) (f64.nearest (get_local $x)))
 )
-
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000002p-1022))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000002p-1022))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1.0000000000001p-1022))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.fffffffffffffp-1022))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.fffffffffffffp-1022))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1.0000000000001p-1022))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x1.0000000000001p-1022))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.fffffffffffffp-1022))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.fffffffffffffp-1022))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.0000000000001p-1022))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1021))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1021))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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-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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p+0))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p+0))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1.8p+0))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1.8p+0))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.b21fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.721fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.721fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.b21fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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+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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1.8p+0))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1.8p+0))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+1))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+1))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.d21fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.521fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.521fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.d21fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.b21fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.721fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.721fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.b21fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.d21fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.521fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.521fb54442d18p+2))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.d21fb54442d18p+2))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+3))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+3))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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.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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (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 (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 -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))
-(assert_return (invoke "add" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
-(assert_return (invoke "add" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "add" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "add" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "add" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf))
-(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
-(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
-(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
-(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf))
-(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
-(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
-(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
-(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf))
-(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
-(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "add" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
-(assert_return (invoke "add" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (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 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 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 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 "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))
-(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 -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000002p-1022))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000002p-1022))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x0.fffffffffffffp-1022))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x1.0000000000001p-1022))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x1.0000000000001p-1022))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x0.fffffffffffffp-1022))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x0.fffffffffffffp-1022))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.0000000000001p-1022))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.0000000000001p-1022))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.fffffffffffffp-1022))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p-1021))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p-1021))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(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 (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-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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1.8p+0))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1.8p+0))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.721fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.b21fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.b21fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.721fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(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 (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+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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1.8p+0))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1.8p+0))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+1))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+1))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.521fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.d21fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.d21fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.521fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.721fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.b21fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.b21fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.721fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.521fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.d21fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.d21fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.521fb54442d18p+2))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+3))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+3))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(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 (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.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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(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 (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 -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))
-(assert_return (invoke "sub" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
-(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "sub" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "sub" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf))
-(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
-(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
-(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
-(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf))
-(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
-(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
-(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
-(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf))
-(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
-(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
-(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (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 (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 -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 "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))
-(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 -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000006p-1022))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000006p-1022))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000006p-1022))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000006p-1022))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp-51))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp-51))
-(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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x0.8p-1022))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x0.8p-1022))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x0.8p-1022))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x0.8p-1022))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p-1022))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p-1022))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p-1020))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p-1020))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p-1020))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p-1020))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1))
-(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 (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-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))
-(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 -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x0.8p-1022))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x0.8p-1022))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x0.8p-1022))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x0.8p-1022))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p-2))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p-2))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-2))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-2))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+1))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+1))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+1))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+1))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1022))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1022))
-(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 (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+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))
-(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 -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000006p-1022))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000006p-1022))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000006p-1022))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000006p-1022))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p-1020))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p-1020))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p-1020))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p-1020))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+1))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+1))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+1))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+1))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.3bd3cc9be45dep+5))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.3bd3cc9be45dep+5))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (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 (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.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))
-(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 -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp-51))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp-51))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp-51))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp-51))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1022))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1022))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1022))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1022))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (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 (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 -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))
-(assert_return (invoke "mul" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
-(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
-(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (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 (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 "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))
-(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 -0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p-52))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p-52))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-52))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-52))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x0.0000000000002p-1022))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x0.0000000000002p-1022))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000002p-1022))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000002p-1022))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const 0x1p+52))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+52))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+52))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+52))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1021))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1021))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1021))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1021))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p-1022))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p-1022))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0.28be60db9391p-1022))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0.28be60db9391p-1022))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.28be60db9391p-1022))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.28be60db9391p-1022))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (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 (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-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))
-(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 -0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p+1021))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p+1021))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p+1021))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p+1021))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-4))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-4))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-4))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-4))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.2p-1022))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.2p-1022))
-(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 (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+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))
-(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 -0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+1022))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+1022))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+1022))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+1022))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p+1))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p+1))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+1))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+1))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-3))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-3))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-3))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-3))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.4p-1022))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.4p-1022))
-(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 (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 -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))
-(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 -0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+3))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+3))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+3))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+3))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d19p-1022))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d19p-1022))
-(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 (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.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))
-(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 -0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c882p+1021))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c882p+1021))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c882p+1021))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c882p+1021))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+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 (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 -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))
-(assert_return (invoke "div" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
-(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "div" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (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 (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 "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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (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 (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 -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))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (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 (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 -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))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (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 (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-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))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (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 (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+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))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (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 (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 -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))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (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 (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.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))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (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 (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 -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))
-(assert_return (invoke "min" (f64.const inf) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
-(assert_return (invoke "min" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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 "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))
-(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 -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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 -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))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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 -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))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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-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))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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+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))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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 -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))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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.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))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(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 (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 -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))
-(assert_return (invoke "max" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
-(assert_return (invoke "max" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "max" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
-(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf))
-(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
-(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf))
-(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
-(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf))
-(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
-(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
-(assert_return (invoke "max" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
-(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
-(assert_return (invoke "max" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (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 (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 "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 0x1p-537))
-(assert_return_canonical_nan (invoke "sqrt" (f64.const -0x1p-1022)))
-(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 0x1.6a09e667f3bcdp-1))
-(assert_return_canonical_nan (invoke "sqrt" (f64.const -0x1p+0)))
-(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 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 0x1.fffffffffffffp+511))
-(assert_return_canonical_nan (invoke "sqrt" (f64.const -inf)))
-(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 "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))
-(assert_return (invoke "floor" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "floor" (f64.const -0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "floor" (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "floor" (f64.const -0x1p-1)) (f64.const -0x1p+0))
-(assert_return (invoke "floor" (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "floor" (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "floor" (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "floor" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.cp+2))
-(assert_return (invoke "floor" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
-(assert_return (invoke "floor" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(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 "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))
-(assert_return (invoke "ceil" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "ceil" (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "ceil" (f64.const 0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "ceil" (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "ceil" (f64.const 0x1p-1)) (f64.const 0x1p+0))
-(assert_return (invoke "ceil" (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "ceil" (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "ceil" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2))
-(assert_return (invoke "ceil" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.cp+2))
-(assert_return (invoke "ceil" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(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 "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))
-(assert_return (invoke "trunc" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "trunc" (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "trunc" (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "trunc" (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "trunc" (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "trunc" (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "trunc" (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "trunc" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2))
-(assert_return (invoke "trunc" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
-(assert_return (invoke "trunc" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(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 "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))
-(assert_return (invoke "nearest" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "nearest" (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "nearest" (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "nearest" (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "nearest" (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "nearest" (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "nearest" (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "nearest" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2))
-(assert_return (invoke "nearest" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
-(assert_return (invoke "nearest" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(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)))
\ No newline at end of file
diff --git a/tests/samples/i64.wast b/tests/samples/i64.wast
index 613349b..280df14 100644
--- a/tests/samples/i64.wast
+++ b/tests/samples/i64.wast
@@ -36,391 +36,3 @@
   (func (export "ge_s") (param $x i64) (param $y i64) (result i32) (i64.ge_s (get_local $x) (get_local $y)))
   (func (export "ge_u") (param $x i64) (param $y i64) (result i32) (i64.ge_u (get_local $x) (get_local $y)))
 )
-
-(assert_return (invoke "add" (i64.const 1) (i64.const 1)) (i64.const 2))
-(assert_return (invoke "add" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "add" (i64.const -1) (i64.const -1)) (i64.const -2))
-(assert_return (invoke "add" (i64.const -1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "add" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_return (invoke "add" (i64.const 0x3fffffff) (i64.const 1)) (i64.const 0x40000000))
-
-(assert_return (invoke "sub" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "sub" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "sub" (i64.const -1) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "sub" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_return (invoke "sub" (i64.const 0x3fffffff) (i64.const -1)) (i64.const 0x40000000))
-
-(assert_return (invoke "mul" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "mul" (i64.const 1) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "mul" (i64.const -1) (i64.const -1)) (i64.const 1))
-(assert_return (invoke "mul" (i64.const 0x1000000000000000) (i64.const 4096)) (i64.const 0))
-(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000001))
-(assert_return (invoke "mul" (i64.const 0x0123456789abcdef) (i64.const 0xfedcba9876543210)) (i64.const 0x2236d88fe5618cf0))
-(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i64.const 1))
-
-(assert_trap (invoke "div_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
-(assert_trap (invoke "div_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
-(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow")
-(assert_return (invoke "div_s" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "div_s" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "div_s" (i64.const 0) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "div_s" (i64.const -1) (i64.const -1)) (i64.const 1))
-(assert_return (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0xc000000000000000))
-(assert_return (invoke "div_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0xffdf3b645a1cac09))
-(assert_return (invoke "div_s" (i64.const 5) (i64.const 2)) (i64.const 2))
-(assert_return (invoke "div_s" (i64.const -5) (i64.const 2)) (i64.const -2))
-(assert_return (invoke "div_s" (i64.const 5) (i64.const -2)) (i64.const -2))
-(assert_return (invoke "div_s" (i64.const -5) (i64.const -2)) (i64.const 2))
-(assert_return (invoke "div_s" (i64.const 7) (i64.const 3)) (i64.const 2))
-(assert_return (invoke "div_s" (i64.const -7) (i64.const 3)) (i64.const -2))
-(assert_return (invoke "div_s" (i64.const 7) (i64.const -3)) (i64.const -2))
-(assert_return (invoke "div_s" (i64.const -7) (i64.const -3)) (i64.const 2))
-(assert_return (invoke "div_s" (i64.const 11) (i64.const 5)) (i64.const 2))
-(assert_return (invoke "div_s" (i64.const 17) (i64.const 7)) (i64.const 2))
-
-(assert_trap (invoke "div_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
-(assert_trap (invoke "div_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
-(assert_return (invoke "div_u" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "div_u" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "div_u" (i64.const -1) (i64.const -1)) (i64.const 1))
-(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0x4000000000000000))
-(assert_return (invoke "div_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x8ff00fef))
-(assert_return (invoke "div_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0x20c49ba5e353f7))
-(assert_return (invoke "div_u" (i64.const 5) (i64.const 2)) (i64.const 2))
-(assert_return (invoke "div_u" (i64.const -5) (i64.const 2)) (i64.const 0x7ffffffffffffffd))
-(assert_return (invoke "div_u" (i64.const 5) (i64.const -2)) (i64.const 0))
-(assert_return (invoke "div_u" (i64.const -5) (i64.const -2)) (i64.const 0))
-(assert_return (invoke "div_u" (i64.const 7) (i64.const 3)) (i64.const 2))
-(assert_return (invoke "div_u" (i64.const 11) (i64.const 5)) (i64.const 2))
-(assert_return (invoke "div_u" (i64.const 17) (i64.const 7)) (i64.const 2))
-
-(assert_trap (invoke "rem_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
-(assert_trap (invoke "rem_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
-(assert_return (invoke "rem_s" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 0) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const -1) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const -807))
-(assert_return (invoke "rem_s" (i64.const 5) (i64.const 2)) (i64.const 1))
-(assert_return (invoke "rem_s" (i64.const -5) (i64.const 2)) (i64.const -1))
-(assert_return (invoke "rem_s" (i64.const 5) (i64.const -2)) (i64.const 1))
-(assert_return (invoke "rem_s" (i64.const -5) (i64.const -2)) (i64.const -1))
-(assert_return (invoke "rem_s" (i64.const 7) (i64.const 3)) (i64.const 1))
-(assert_return (invoke "rem_s" (i64.const -7) (i64.const 3)) (i64.const -1))
-(assert_return (invoke "rem_s" (i64.const 7) (i64.const -3)) (i64.const 1))
-(assert_return (invoke "rem_s" (i64.const -7) (i64.const -3)) (i64.const -1))
-(assert_return (invoke "rem_s" (i64.const 11) (i64.const 5)) (i64.const 1))
-(assert_return (invoke "rem_s" (i64.const 17) (i64.const 7)) (i64.const 3))
-
-(assert_trap (invoke "rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
-(assert_trap (invoke "rem_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
-(assert_return (invoke "rem_u" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "rem_u" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "rem_u" (i64.const -1) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
-(assert_return (invoke "rem_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x80000001))
-(assert_return (invoke "rem_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 809))
-(assert_return (invoke "rem_u" (i64.const 5) (i64.const 2)) (i64.const 1))
-(assert_return (invoke "rem_u" (i64.const -5) (i64.const 2)) (i64.const 1))
-(assert_return (invoke "rem_u" (i64.const 5) (i64.const -2)) (i64.const 5))
-(assert_return (invoke "rem_u" (i64.const -5) (i64.const -2)) (i64.const -5))
-(assert_return (invoke "rem_u" (i64.const 7) (i64.const 3)) (i64.const 1))
-(assert_return (invoke "rem_u" (i64.const 11) (i64.const 5)) (i64.const 1))
-(assert_return (invoke "rem_u" (i64.const 17) (i64.const 7)) (i64.const 3))
-
-(assert_return (invoke "and" (i64.const 1) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "and" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "and" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "and" (i64.const 0) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "and" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xf0f0f0f0))
-(assert_return (invoke "and" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
-
-(assert_return (invoke "or" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "or" (i64.const 0) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "or" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "or" (i64.const 0) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "or" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
-(assert_return (invoke "or" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
-(assert_return (invoke "or" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xffffffff))
-(assert_return (invoke "or" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
-
-(assert_return (invoke "xor" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "xor" (i64.const 0) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "xor" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "xor" (i64.const 0) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "xor" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
-(assert_return (invoke "xor" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
-(assert_return (invoke "xor" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "xor" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
-(assert_return (invoke "xor" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0x0f0f0f0f))
-(assert_return (invoke "xor" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0))
-
-(assert_return (invoke "shl" (i64.const 1) (i64.const 1)) (i64.const 2))
-(assert_return (invoke "shl" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "shl" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
-(assert_return (invoke "shl" (i64.const 0xffffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
-(assert_return (invoke "shl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "shl" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "shl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
-(assert_return (invoke "shl" (i64.const 1) (i64.const 64)) (i64.const 1))
-(assert_return (invoke "shl" (i64.const 1) (i64.const 65)) (i64.const 2))
-(assert_return (invoke "shl" (i64.const 1) (i64.const -1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "shl" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
-
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const 1)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
-(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0xc000000000000000))
-(assert_return (invoke "shr_s" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 64)) (i64.const 1))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 65)) (i64.const 0))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
-(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const 64)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const 65)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const -1)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
-
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const 1)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "shr_u" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
-(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x4000000000000000))
-(assert_return (invoke "shr_u" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 64)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 65)) (i64.const 0))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const 64)) (i64.const -1))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const 65)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const -1)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
-
-(assert_return (invoke "rotl" (i64.const 1) (i64.const 1)) (i64.const 2))
-(assert_return (invoke "rotl" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "rotl" (i64.const -1) (i64.const 1)) (i64.const -1))
-(assert_return (invoke "rotl" (i64.const 1) (i64.const 64)) (i64.const 1))
-(assert_return (invoke "rotl" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x579b30ec048d159d))
-(assert_return (invoke "rotl" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0xe000000dc000000f))
-(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x013579a2469deacf))
-(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x55e891a77ab3c04e))
-(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x013579a2469deacf))
-(assert_return (invoke "rotl" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0xcf013579ae529dea))
-(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x55e891a77ab3c04e))
-(assert_return (invoke "rotl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
-(assert_return (invoke "rotl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 1))
-
-(assert_return (invoke "rotr" (i64.const 1) (i64.const 1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "rotr" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "rotr" (i64.const -1) (i64.const 1)) (i64.const -1))
-(assert_return (invoke "rotr" (i64.const 1) (i64.const 64)) (i64.const 1))
-(assert_return (invoke "rotr" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x55e6cc3b01234567))
-(assert_return (invoke "rotr" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0x0fe000000dc00000))
-(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x6891a77ab3c04d5e))
-(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x57a2469deacf0139))
-(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x6891a77ab3c04d5e))
-(assert_return (invoke "rotr" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0x94a77ab3c04d5e6b))
-(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x57a2469deacf0139))
-(assert_return (invoke "rotr" (i64.const 1) (i64.const 63)) (i64.const 2))
-(assert_return (invoke "rotr" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
-
-(assert_return (invoke "clz" (i64.const 0xffffffffffffffff)) (i64.const 0))
-(assert_return (invoke "clz" (i64.const 0)) (i64.const 64))
-(assert_return (invoke "clz" (i64.const 0x00008000)) (i64.const 48))
-(assert_return (invoke "clz" (i64.const 0xff)) (i64.const 56))
-(assert_return (invoke "clz" (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_return (invoke "clz" (i64.const 1)) (i64.const 63))
-(assert_return (invoke "clz" (i64.const 2)) (i64.const 62))
-(assert_return (invoke "clz" (i64.const 0x7fffffffffffffff)) (i64.const 1))
-
-(assert_return (invoke "ctz" (i64.const -1)) (i64.const 0))
-(assert_return (invoke "ctz" (i64.const 0)) (i64.const 64))
-(assert_return (invoke "ctz" (i64.const 0x00008000)) (i64.const 15))
-(assert_return (invoke "ctz" (i64.const 0x00010000)) (i64.const 16))
-(assert_return (invoke "ctz" (i64.const 0x8000000000000000)) (i64.const 63))
-(assert_return (invoke "ctz" (i64.const 0x7fffffffffffffff)) (i64.const 0))
-
-(assert_return (invoke "popcnt" (i64.const -1)) (i64.const 64))
-(assert_return (invoke "popcnt" (i64.const 0)) (i64.const 0))
-(assert_return (invoke "popcnt" (i64.const 0x00008000)) (i64.const 1))
-(assert_return (invoke "popcnt" (i64.const 0x8000800080008000)) (i64.const 4))
-(assert_return (invoke "popcnt" (i64.const 0x7fffffffffffffff)) (i64.const 63))
-(assert_return (invoke "popcnt" (i64.const 0xAAAAAAAA55555555)) (i64.const 32))
-(assert_return (invoke "popcnt" (i64.const 0x99999999AAAAAAAA)) (i64.const 32))
-(assert_return (invoke "popcnt" (i64.const 0xDEADBEEFDEADBEEF)) (i64.const 48))
-
-(assert_return (invoke "eqz" (i64.const 0)) (i32.const 1))
-(assert_return (invoke "eqz" (i64.const 1)) (i32.const 0))
-(assert_return (invoke "eqz" (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "eqz" (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "eqz" (i64.const 0xffffffffffffffff)) (i32.const 0))
-
-(assert_return (invoke "eq" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "eq" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "eq" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "eq" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "eq" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
-
-(assert_return (invoke "ne" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "ne" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "ne" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "ne" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "ne" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
-
-(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "lt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
-
-(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "lt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
-
-(assert_return (invoke "le_s" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "le_s" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
-
-(assert_return (invoke "le_u" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "le_u" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "le_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
-
-(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "gt_s" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
-
-(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "gt_u" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
-
-(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "ge_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
-
-(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "ge_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
\ No newline at end of file
diff --git a/wasm.cabal b/wasm.cabal
index cc2b0b8..8137466 100644
--- a/wasm.cabal
+++ b/wasm.cabal
@@ -49,6 +49,7 @@ test-suite test
       base >=4.6 && <5.0
     , bytestring >=0.10 && <0.11
     , filepath >=1.3 && <1.5
+    , directory >= 1.3
     , mtl ==2.2.1
     , tasty >=0.7
     , tasty-hunit >=0.4.1 && <0.10